import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';
import 'package:get/get.dart';
import 'package:webview_flutter/webview_flutter.dart';
import 'dart:io' show Platform;
import 'dart:convert';
import 'package:webview_flutter_android/webview_flutter_android.dart';
import 'package:webview_flutter_wkwebview/webview_flutter_wkwebview.dart';
import '../../common/routers/index.dart';
import '../../common/services/user_service.dart';
import '../../common/services/storage_service.dart';
import '../../common/services/amap_location_service.dart';

/// AI 页面控制器
///
/// 🎯 核心职责：
/// 1. 管理 WebView 加载本地 AI HTML
/// 2. 处理页面加载状态
/// 3. 错误处理和重新加载
class AiController extends GetxController {
  // 静态常量
  static const String tag = 'AiController';

  // WebView 控制器
  late final WebViewController webViewController;

  // 响应式状态
  final isLoading = true.obs;
  final hasError = false.obs;
  final errorMessage = ''.obs;
  final loadingProgress = 0.obs;

  // 🎤 语音录音状态管理
  final isVoiceRecording = false.obs;
  final isVoiceProcessing = false.obs;

  // 🔒 防止多次处理的锁
  bool _isProcessingAudio = false;
  bool _hasWebViewLoaded = false;
  Worker? _locationSyncWorker;
  AmapLocationService? _amapLocationService;

  // 构造函数
  AiController() {
    debugPrint('$tag: Constructor');
  }

  /// 设置加载状态
  void setLoading(bool loading) {
    isLoading.value = loading;
    if (loading) {
      hasError.value = false;
    }
  }

  /// 设置错误状态
  void setError(bool error, {String message = ''}) {
    hasError.value = error;
    errorMessage.value = message;
    if (error) {
      isLoading.value = false;
    }
  }

  /// 更新加载进度
  void updateLoadingProgress(int progress) {
    loadingProgress.value = progress;
  }

  /// 重新加载
  void reload() {
    debugPrint('$tag: 重新加载 AI 页面');
    _loadHtmlFromAssets();
  }

  /// 从资源文件加载 HTML
  Future<void> _loadHtmlFromAssets() async {
    setLoading(true);
    _hasWebViewLoaded = false;
    try {
      // 使用延迟确保 WebView 完全初始化
      await Future.delayed(const Duration(milliseconds: 100));

      if (Platform.isIOS) {
        // iOS: 直接加载 Flutter 资源文件，这样可以正确处理相对路径
        await webViewController.loadFlutterAsset('assets/ai-html/sousuo.html');
        debugPrint('$tag: iOS - 使用 loadFlutterAsset 加载 HTML 文件');
      } else {
        // Android: 改用 loadFlutterAsset，与iOS保持一致
        // 这样可以确保相对路径的资源文件（CSS、JS、图片等）能正确加载
        await webViewController.loadFlutterAsset('assets/ai-html/sousuo.html');
        debugPrint('$tag: Android - 使用 loadFlutterAsset 加载 HTML 文件（避免相对路径问题）');
      }
    } catch (e) {
      debugPrint('$tag: ❌ 加载本地 HTML 文件出错: $e');
      setError(true, message: '加载本地 HTML 文件出错: $e');
    }
  }

  @override
  void onInit() {
    super.onInit();
    debugPrint('$tag: onInit');

    // 🌐 配置 WebView 创建参数，允许跨域和本地文件访问
    late final PlatformWebViewControllerCreationParams params;
    if (WebViewPlatform.instance is AndroidWebViewPlatform) {
      params = AndroidWebViewControllerCreationParams(
        // 🔥 关键：使用 AndroidWebViewController 的特定配置
      );
    } else if (WebViewPlatform.instance is WebKitWebViewPlatform) {
      params = WebKitWebViewControllerCreationParams(
        allowsInlineMediaPlayback: true,
        mediaTypesRequiringUserAction: const <PlaybackMediaTypes>{},
      );
    } else {
      params = const PlatformWebViewControllerCreationParams();
    }

    // 初始化 WebView 控制器
    // 🌐 跨域配置说明：
    // webview_flutter 4.x 默认允许跨域访问（Access-Control-Allow-Origin: *）
    // 无需额外配置即可访问所有来源的资源
    webViewController = WebViewController.fromPlatformCreationParams(params)
      ..setJavaScriptMode(JavaScriptMode.unrestricted)
      ..setBackgroundColor(const Color(0x00000000))
      ..setNavigationDelegate(
        NavigationDelegate(
          onProgress: (int progress) {
            updateLoadingProgress(progress);
          },
          onPageStarted: (String url) {
            debugPrint('$tag: WebView 页面开始加载: $url');
          },
          onPageFinished: (String url) {
            debugPrint('$tag: WebView 页面加载完成: $url');
            setLoading(false);
            _hasWebViewLoaded = true;
            
            // 🔥 注入console捕获代码
            _injectConsoleCapture();
            
            // 检查Vue是否加载成功
            _checkVueLoaded();
            
            // 🔥 注入敏感词数据（避免CORS问题）
            _injectForbiddenWords();
            
            _dispatchUserInfoToWebView(log: false, requirePageReady: false);
          },
          onWebResourceError: (WebResourceError error) {
            // 🔧 优化：过滤掉常见的无关错误和资源加载失败

            // 1. 过滤掉占位符URL
            if (error.url != null &&
                (error.url!.contains('placeholder.com') ||
                    error.url!.contains('about:blank'))) {
              return;
            }

            // 2. 过滤掉图片资源加载失败（不影响页面主要功能）
            if (error.url != null &&
                (error.url!.endsWith('.png') ||
                    error.url!.endsWith('.jpg') ||
                    error.url!.endsWith('.jpeg') ||
                    error.url!.endsWith('.webp') ||
                    error.url!.endsWith('.gif') ||
                    error.url!.contains('/img/') ||
                    error.url!.contains('imgdef'))) {
              debugPrint('$tag: WebView 图片资源加载失败 (已忽略): ${error.url}');
              return;
            }

            // 3. 过滤掉网络相关的非致命错误
            if (error.errorCode == -2 || // net::ERR_INTERNET_DISCONNECTED
                error.errorCode == -3 || // net::ERR_NETWORK_CHANGED
                error.errorCode == -6 || // net::ERR_FILE_NOT_FOUND (for assets)
                error.errorCode == -10) {
              // net::ERR_UNKNOWN_URL_SCHEME
              debugPrint(
                '$tag: WebView 非致命错误 (已忽略): ${error.description}, URL: ${error.url}',
              );
              return;
            }

            // 4. 只有严重错误才显示错误提示（影响页面主体加载的错误）
            debugPrint(
              '$tag: ❌ WebView 加载错误: ${error.description}, 错误代码: ${error.errorCode}, URL: ${error.url}',
            );
            setError(
              true,
              message: '${error.description} (${error.errorCode})',
            );
          },
        ),
      )
      // 🔥 添加JavaScript通道，让WebView中的JS可以调用Flutter方法（类似Android的JavascriptInterface）
      ..addJavaScriptChannel(
        'Android', // 🎯 与MyApplication2保持一致的接口名
        onMessageReceived: (JavaScriptMessage message) {
          _handleJavaScriptMessage(message);
        },
      )
      // 🔥 添加console日志通道，捕获JavaScript日志和错误
      ..addJavaScriptChannel(
        'ConsoleLog',
        onMessageReceived: (JavaScriptMessage message) {
          debugPrint('$tag: [WebView Console] ${message.message}');
        },
      );

    // Android 特定配置
    // 🌐 跨域访问和本地文件访问配置
    if (webViewController.platform is AndroidWebViewController) {
      final androidController =
          webViewController.platform as AndroidWebViewController;
      
      try {
        androidController.setMediaPlaybackRequiresUserGesture(false);
        debugPrint('$tag: ✅ 媒体自动播放: 已启用');
      } catch (e) {
        debugPrint('$tag: ⚠️ 设置媒体自动播放失败: $e');
      }

      // 🔥 关键配置1：允许WebView访问本地文件系统
      // 这样HTML中的fetch('./forbiddenWords.json')才能正常工作
      try {
        androidController.setAllowFileAccess(true);
        debugPrint('$tag: ✅ 本地文件访问: 已启用');
      } catch (e) {
        debugPrint('$tag: ❌ 设置本地文件访问失败: $e');
      }
      
      // 🔥 关键配置2和3：允许file://协议跨域访问
      // 注意：webview_flutter 4.x 的 AndroidWebViewController 不直接提供这些方法
      // 需要通过原生配置或使用 loadFlutterAsset（已使用）来解决
      // 
      // 这些方法在当前版本中不可用：
      // - setAllowFileAccessFromFileURLs(true)
      // - setAllowUniversalAccessFromFileURLs(true)
      //
      // ✅ 解决方案：使用 loadFlutterAsset 加载HTML（已在 _loadHtmlFromAssets 中实施）
      // 这样 Flutter 会自动处理本地文件的相对路径，无需额外的跨域配置
      
      debugPrint('$tag: 💡 使用 loadFlutterAsset 方式，自动支持本地文件互访');
      debugPrint('$tag: 💡 如需更多控制，可在原生 Android 代码中配置 WebView Settings');

      // 🔥 启用WebView调试模式，方便查看控制台日志
      try {
        AndroidWebViewController.enableDebugging(true);
        debugPrint('$tag: ✅ 调试模式: 已启用');
      } catch (e) {
        debugPrint('$tag: ⚠️ 启用调试模式失败: $e');
      }

      debugPrint('$tag: ✅ Android WebView 配置完成');
      debugPrint('$tag: 💡 如果无法读取JSON文件，请查看上方的警告信息');
    }

    // 加载 HTML
    _loadHtmlFromAssets();
    _initLocationSync();
  }

  @override
  void onReady() {
    super.onReady();
    debugPrint('$tag: onReady');
  }

  @override
  void onClose() {
    debugPrint('$tag: onClose');
    _locationSyncWorker?.dispose();
    super.onClose();
  }

  // ========== 🔧 WebView辅助方法 ==========

  /// 🔥 注入console日志捕获代码
  void _injectConsoleCapture() {
    try {
      webViewController.runJavaScript('''
        (function() {
          const originalLog = console.log;
          const originalError = console.error;
          const originalWarn = console.warn;
          
          console.log = function(...args) {
            try {
              if (window.ConsoleLog) {
                ConsoleLog.postMessage('[LOG] ' + args.join(' '));
              }
            } catch(e) {}
            originalLog.apply(console, args);
          };
          
          console.error = function(...args) {
            try {
              if (window.ConsoleLog) {
                ConsoleLog.postMessage('[ERROR] ' + args.join(' '));
              }
            } catch(e) {}
            originalError.apply(console, args);
          };
          
          console.warn = function(...args) {
            try {
              if (window.ConsoleLog) {
                ConsoleLog.postMessage('[WARN] ' + args.join(' '));
              }
            } catch(e) {}
            originalWarn.apply(console, args);
          };
          
          // 捕获未捕获的错误
          window.addEventListener('error', function(e) {
            try {
              if (window.ConsoleLog) {
                ConsoleLog.postMessage('[UNCAUGHT ERROR] ' + e.message + ' at ' + e.filename + ':' + e.lineno);
              }
            } catch(err) {}
          });
          
          console.log('✅ Console捕获已注入');
        })();
      ''');
      debugPrint('$tag: ✅ Console捕获代码已注入');
    } catch (e) {
      debugPrint('$tag: ❌ 注入Console捕获代码失败: $e');
    }
  }

  /// 🔥 检查Vue是否正确加载
  Future<void> _checkVueLoaded() async {
    try {
      await Future.delayed(const Duration(milliseconds: 500)); // 等待一下确保JS执行完
      
      final result = await webViewController.runJavaScriptReturningResult('''
        (function() {
          if (typeof Vue === 'undefined') {
            return 'Vue未加载';
          }
          if (typeof window.app === 'undefined') {
            return 'Vue已加载，但app实例未创建';
          }
          if (!window.app._isMounted) {
            return 'app实例已创建，但未挂载';
          }
          return 'Vue正常运行';
        })()
      ''');
      
      debugPrint('$tag: 🔍 Vue状态检查: $result');
      
      // 如果Vue或app未正确加载，记录错误
      if (result.toString().contains('未')) {
        debugPrint('$tag: ⚠️ 检测到Vue问题: $result');
        debugPrint('$tag: 💡 可能原因：1) JS文件路径错误 2) JS文件加载失败 3) JS执行出错');
      }
    } catch (e) {
      debugPrint('$tag: ❌ 检查Vue状态失败: $e');
    }
  }

  /// 🔥 注入敏感词数据到WebView（避免CORS问题）
  Future<void> _injectForbiddenWords() async {
    try {
      debugPrint('$tag: 🔍 开始加载敏感词数据...');
      
      // 从assets加载forbiddenWords.json
      final String jsonString = await rootBundle.loadString(
        'assets/ai-html/forbiddenWords.json',
      );
      
      // 解析JSON以验证格式
      final Map<String, dynamic> jsonData = jsonDecode(jsonString);
      final List<dynamic> words = jsonData['words'] as List<dynamic>;
      
      debugPrint('$tag: ✅ 敏感词数据加载成功，共 ${words.length} 个词');
      
      // 转义JSON字符串中的特殊字符
      final String escapedJson = jsonString
          .replaceAll('\\', '\\\\')
          .replaceAll("'", "\\'")
          .replaceAll('\n', '\\n')
          .replaceAll('\r', '\\r')
          .replaceAll('\t', '\\t');
      
      // 注入到WebView
      final String jsCode = '''
        (function() {
          try {
            // 解析JSON数据
            const forbiddenWordsData = JSON.parse('$escapedJson');
            
            // 注入到全局变量
            if (typeof window.app !== 'undefined' && window.app.forbiddenWords !== undefined) {
              // Vue app 存在，注入到Vue实例
              window.app.forbiddenWords = forbiddenWordsData.words;
              console.log('✅ [Flutter注入] 敏感词已注入到Vue实例，共 ' + forbiddenWordsData.words.length + ' 个');
            } else {
              // 直接注入到window
              window.forbiddenWordsData = forbiddenWordsData;
              console.log('✅ [Flutter注入] 敏感词已注入到window，共 ' + forbiddenWordsData.words.length + ' 个');
            }
            
            return 'success';
          } catch (e) {
            console.error('❌ [Flutter注入] 注入敏感词失败:', e.message);
            return 'error: ' + e.message;
          }
        })()
      ''';
      
      final result = await webViewController.runJavaScriptReturningResult(jsCode);
      
      if (result.toString().contains('success')) {
        debugPrint('$tag: ✅ 敏感词数据已成功注入到WebView');
      } else {
        debugPrint('$tag: ⚠️ 敏感词注入结果: $result');
      }
    } catch (e) {
      debugPrint('$tag: ❌ 注入敏感词数据失败: $e');
      debugPrint('$tag: 💡 这不会影响主要功能，但敏感词过滤将不可用');
    }
  }

  // ========== 📱 JavaScript通道方法（类似Android的JavascriptInterface） ==========

  /// 🔥 处理来自JavaScript的消息调用
  ///
  /// 参考MyApplication2的实现方式，支持以下方法：
  /// - openActivity(activityId): 打开活动详情
  /// - openReview(reviewId): 打开评论详情
  /// - getUserInfo(): 获取用户信息（经纬度、用户ID）
  void _handleJavaScriptMessage(JavaScriptMessage message) {
    try {
      debugPrint('$tag: 📨 收到JavaScript消息: ${message.message}');

      // 解析消息（格式: "method:params"）
      final String messageStr = message.message;
      final parts = messageStr.split(':');

      if (parts.isEmpty) {
        debugPrint('$tag: ❌ 消息格式错误');
        return;
      }

      final String method = parts[0];
      final String? params = parts.length > 1
          ? parts.sublist(1).join(':')
          : null;

      // 根据方法名分发处理
      switch (method) {
        case 'openActivity':
          if (params != null) {
            _openActivity(params);
          }
          break;
        case 'openReview':
          if (params != null) {
            _openReview(params);
          }
          break;
        case 'getUserInfo':
          _getUserInfo();
          break;
        default:
          debugPrint('$tag: ⚠️ 未知的方法调用: $method');
      }
    } catch (e) {
      debugPrint('$tag: ❌ 处理JavaScript消息失败: $e');
    }
  }

  /// 🎯 打开活动详情页面
  void _openActivity(String activityId) {
    try {
      debugPrint('$tag: 🎯 打开活动详情 - activityId: $activityId');

      // 解析activityId
      final int? id = int.tryParse(activityId);
      if (id == null) {
        debugPrint('$tag: ❌ activityId格式错误: $activityId');
        return;
      }

      // 🚀 跳转到活动详情页面（与activity_index中的跳转方式一致）
      Get.toNamed(
        RouteNames.activityActivityDetial,
        arguments: {
          'activityId': id,
          'fromPage': 'ai_search', // 标记来源为AI搜索
        },
      );

      debugPrint('$tag: ✅ 已触发跳转到活动详情页');
    } catch (e) {
      debugPrint('$tag: ❌ 打开活动详情失败: $e');
    }
  }

  /// 📝 打开评论详情页面
  void _openReview(String reviewId) {
    try {
      debugPrint('$tag: 📝 打开评论详情 - reviewId: $reviewId');

      // TODO: 实现评论详情页面跳转
      // 目前暂时只记录日志
      debugPrint('$tag: ⚠️ 评论详情页面功能待实现');
    } catch (e) {
      debugPrint('$tag: ❌ 打开评论详情失败: $e');
    }
  }

  /// 👤 获取用户信息并返回给JavaScript
  ///
  /// 返回JSON格式：{"latitude": "xxx", "longitude": "xxx", "userId": "xxx"}
  void _getUserInfo() {
    _dispatchUserInfoToWebView();
  }

  void _initLocationSync() {
    if (!Get.isRegistered<AmapLocationService>()) {
      debugPrint('$tag: ℹ️ AmapLocationService 未注册，跳过实时定位同步');
      return;
    }
    _amapLocationService = Get.find<AmapLocationService>();
    _locationSyncWorker = everAll([
      _amapLocationService!.currentLatitude,
      _amapLocationService!.currentLongitude,
    ], (_) => _handleLocationUpdated());
    debugPrint('$tag: 📡 已监听定位变化，实时同步到WebView');
  }

  Future<void> _handleLocationUpdated() async {
    if (!_hasWebViewLoaded) return;
    await _dispatchUserInfoToWebView(log: false, requirePageReady: true);
  }

  Map<String, dynamic> _buildUserInfoPayload() {
    final userService = Get.find<UserService>();
    final storageService = Get.find<StorageService>();
    AmapLocationService? amapLocationService = _amapLocationService;

    if (amapLocationService == null &&
        Get.isRegistered<AmapLocationService>()) {
      amapLocationService = Get.find<AmapLocationService>();
      _amapLocationService = amapLocationService;
    }

    final storedLatitude = storageService.getString('user_latitude');
    final storedLongitude = storageService.getString('user_longitude');
    String? locationLabel = storageService.getString('user_location_text');

    String latitude = '0.0';
    String longitude = '0.0';

    if (amapLocationService != null) {
      final hasLiveLocation = amapLocationService.isSuccess;
      final serviceLatitude = amapLocationService.latitude;
      final serviceLongitude = amapLocationService.longitude;

      if (hasLiveLocation) {
        latitude = _formatCoordinate(serviceLatitude);
        longitude = _formatCoordinate(serviceLongitude);
        locationLabel = amapLocationService.locationText;
      } else if (storedLatitude != null && storedLongitude != null) {
        latitude = storedLatitude;
        longitude = storedLongitude;
      } else {
        latitude = _formatCoordinate(serviceLatitude);
        longitude = _formatCoordinate(serviceLongitude);
      }
    } else if (storedLatitude != null && storedLongitude != null) {
      latitude = storedLatitude;
      longitude = storedLongitude;
    }

    final Map<String, dynamic> userInfo = {
      'latitude': latitude,
      'longitude': longitude,
      'userId': userService.currentUserProfile?.userid?.toString() ?? '',
    };

    if (locationLabel != null && locationLabel.isNotEmpty) {
      userInfo['locationText'] = locationLabel;
    }

    return userInfo;
  }

  Future<void> _dispatchUserInfoToWebView({
    bool log = true,
    bool requirePageReady = false,
  }) async {
    try {
      if (requirePageReady && !_hasWebViewLoaded) {
        debugPrint('$tag: ⏳ WebView 未就绪，跳过定位同步');
        return;
      }

      final userInfo = _buildUserInfoPayload();
      final String jsonStr = jsonEncode(userInfo);
      if (log) {
        debugPrint('$tag: 📤 同步用户信息: $jsonStr');
      }

      await webViewController.runJavaScript('''
        if (typeof window.onUserInfoReceived === 'function') {
          window.onUserInfoReceived('$jsonStr');
        }
      ''');
    } catch (e) {
      debugPrint('$tag: ❌ 同步用户信息失败: $e');
    }
  }

  String _formatCoordinate(double value) {
    return value.toStringAsFixed(6);
  }

  // ========== 🎤 语音功能方法 ==========

  /// 🎤 开始语音录音（由MainController调用）
  void startVoiceRecording() {
    debugPrint(
      '$tag: 🎤 [状态] 开始录音 - 当前状态: recording=${isVoiceRecording.value}, processing=${isVoiceProcessing.value}, lock=$_isProcessingAudio',
    );

    // 🔒 如果正在处理音频，先强制重置
    if (_isProcessingAudio) {
      debugPrint('$tag: ⚠️ [状态] 检测到音频处理中，强制重置状态');
      _forceResetVoiceState();
    }

    isVoiceRecording.value = true;
    isVoiceProcessing.value = false;
    debugPrint('$tag: ✅ [状态] 录音状态已设置');
  }

  /// 🎤 停止语音录音，开始处理
  void stopVoiceRecording() {
    debugPrint(
      '$tag: 🎤 [状态] 停止录音，开始处理 - 当前状态: recording=${isVoiceRecording.value}, processing=${isVoiceProcessing.value}',
    );

    isVoiceRecording.value = false;
    isVoiceProcessing.value = true;
    debugPrint('$tag: ✅ [状态] 处理状态已设置');
  }

  /// 🎤 完成语音处理
  void finishVoiceProcessing() {
    debugPrint(
      '$tag: 🎤 [状态] 完成语音处理 - 当前状态: recording=${isVoiceRecording.value}, processing=${isVoiceProcessing.value}',
    );

    isVoiceRecording.value = false;
    isVoiceProcessing.value = false;
    _isProcessingAudio = false;
    debugPrint('$tag: ✅ [状态] 所有状态已重置');
  }

  /// 🔧 强制重置语音状态（用于修复状态混乱）
  void _forceResetVoiceState() {
    debugPrint('$tag: 🔧 [重置] 强制重置所有语音状态');
    isVoiceRecording.value = false;
    isVoiceProcessing.value = false;
    _isProcessingAudio = false;
    debugPrint('$tag: ✅ [重置] 状态重置完成');
  }

  /// 🔧 公开的强制重置方法（供外部调用）
  void forceResetVoiceState() {
    _forceResetVoiceState();
  }

  /// 🎤 处理来自Flutter的音频数据
  Future<void> processAudioFromFlutter(String audioData) async {
    // 🔒 防重复处理锁检查
    if (_isProcessingAudio) {
      debugPrint('$tag: ⚠️ [音频处理] 已有音频在处理中，跳过本次请求');
      return;
    }

    _isProcessingAudio = true;
    debugPrint('$tag: 🎤 [音频处理] 开始处理音频数据，长度: ${audioData.length}');

    try {
      // 切换到处理状态
      stopVoiceRecording();

      // 等待WebView完全加载
      if (isLoading.value) {
        debugPrint('$tag: ⏳ [音频处理] WebView还在加载中，等待加载完成...');
        // 等待最多3秒钟WebView加载完成
        int attempts = 0;
        while (isLoading.value && attempts < 30) {
          await Future.delayed(const Duration(milliseconds: 100));
          attempts++;
        }
      }

      if (isLoading.value) {
        debugPrint('$tag: ❌ [音频处理] WebView加载超时，无法处理音频');
        finishVoiceProcessing();
        return;
      }

      // 🎯 关键修复：使用与Android原生相同的调用方式
      // 构造JavaScript调用代码（参考MyApplication2的实现）
      final jsCode =
          '''
        (function() {
          try {
            if (typeof processAudio === 'function') {
              return processAudio('$audioData');
            } else {
              return 'processAudio function not found';
            }
          } catch (e) {
            return 'JS Error: ' + e.message;
          }
        })()
      ''';

      debugPrint('$tag: 📲 [音频处理] 向WebView发送JavaScript调用...');

      // 🔥 关键修复：使用runJavaScriptReturningResult并等待结果
      // 这样可以确保JavaScript执行完成后才继续，避免重复调用
      final result = await webViewController.runJavaScriptReturningResult(
        jsCode,
      );
      debugPrint('$tag: ✅ [音频处理] JavaScript执行完成，结果: $result');

      // 🔧 优化：减少延迟时间，避免状态混乱
      await Future.delayed(const Duration(milliseconds: 800));

      // 🔧 检查状态是否还是处理中（防止被其他操作干扰）
      if (_isProcessingAudio && isVoiceProcessing.value) {
        finishVoiceProcessing();
      } else {
        debugPrint('$tag: ⚠️ [音频处理] 状态已被外部改变，跳过完成处理');
        _isProcessingAudio = false;
      }
    } catch (e) {
      debugPrint('$tag: ❌ [音频处理] 处理音频数据失败: $e');
      finishVoiceProcessing(); // 出错时也要结束处理状态
    }
  }

  /// 🎤 测试语音识别功能
  void testVoiceRecognition() {
    try {
      const jsCode = '''
        (function() {
          try {
            if (typeof testVoiceRecognition === 'function') {
              testVoiceRecognition();
              return 'Test voice recognition started';
            } else {
              return 'testVoiceRecognition function not found';
            }
          } catch (e) {
            return 'JS Error: ' + e.message;
          }
        })()
      ''';

      webViewController.runJavaScript(jsCode);
      debugPrint('$tag: 🧪 测试语音识别功能已启动');
    } catch (e) {
      debugPrint('$tag: ❌ 测试语音识别失败: $e');
    }
  }

  /// 🔧 强制重置AI检索状态（用于调试和测试）
  void forceResetAIState() {
    try {
      const jsCode = '''
        (function() {
          try {
            if (window.app) {
              console.log('🔄 强制重置AI检索状态');
              window.app.isLoading = false;
              window.app.isThinking = false;
              window.app.thinkingStage = '';
              if (window.app.stopLoadingAnimation) {
                window.app.stopLoadingAnimation();
              }
              return 'AI state reset successfully';
            } else {
              return 'Vue app not found';
            }
          } catch (e) {
            return 'JS Error: ' + e.message;
          }
        })()
      ''';

      webViewController.runJavaScript(jsCode);
      debugPrint('$tag: 🔧 强制重置AI状态完成');
    } catch (e) {
      debugPrint('$tag: ❌ 强制重置AI状态失败: $e');
    }
  }
}
